import { defineStore } from 'pinia';
import { authApi, wechatApi, userApi, uploadApi } from '../api/services.js';
import { TokenManager } from '../api/config.js';

export const useUserStore = defineStore('user', {
  state: () => ({
    user: null,
    isAuthenticated: false,
    userWorks: [],
    wechatQRCode: null,
    loginLoading: false
  }),
  
  getters: {
    getUserInfo: (state) => state.user,
    isLoggedIn: (state) => state.isAuthenticated,
    getUserWorks: (state) => state.userWorks
  },
  
  actions: {
    /**
     * 用户登录
     * @param {Object} credentials - 登录凭据
     * @param {string} credentials.username - 用户名
     * @param {string} credentials.password - 密码
     * @returns {Promise<boolean>} 登录是否成功
     */
    async login(credentials) {
      this.loginLoading = true;
      try {
        console.log('调用登录API，参数:', credentials);
        // 调用真实的登录API
        const userData = await authApi.login(credentials);
        console.log('登录API返回数据:', userData);
        
        // 检查返回数据结构
        if (!userData) {
          console.error('登录API返回数据为空');
          throw new Error('登录API返回数据为空');
        }
        
        // 处理不同的响应数据结构
        let actualUserData = userData;
        if (userData.data) {
          actualUserData = userData.data;
          console.log('使用userData.data:', actualUserData);
        } else if (userData.user) {
          actualUserData = userData.user;
          console.log('使用userData.user:', actualUserData);
        }
        
        // 检查token
        const token = actualUserData.token || userData.token;
        if (!token) {
          console.error('未找到token，userData:', actualUserData);
          throw new Error('登录响应中未找到token');
        }
        
        console.log('提取到的token:', token);
        // 保存token
        TokenManager.setToken(token);
        
        // 登录成功，设置用户信息
        console.log('准备设置用户信息:', actualUserData);
        this.setUser(actualUserData);
        console.log('用户信息设置完成，当前状态:', {
          user: this.user,
          isAuthenticated: this.isAuthenticated
        });
        return true;
      } catch (error) {
        console.error('登录失败:', error);
        // 重新抛出错误，让组件能够捕获并显示错误信息
        throw error;
      } finally {
        this.loginLoading = false;
      }
    },
    
    /**
     * 用户注册
     * @param {Object} userData - 注册数据
     * @param {string} userData.username - 用户名
     * @param {string} userData.password - 密码
     * @param {string} userData.email - 邮箱
     * @param {string} userData.nickname - 昵称
     * @returns {Promise<boolean>} 注册是否成功
     */
    async register(userData) {
      try {
        // 调用真实的注册API
        const result = await authApi.register(userData);
        console.log('用户注册成功:', result);
        return true;
      } catch (error) {
        console.error('注册失败:', error);
        return false;
      }
    },
    
    /**
     * 生成微信登录二维码
     * @returns {Promise<Object>} 二维码数据
     */
    async generateWechatQR() {
      this.loginLoading = true;
      try {
        // 调用真实的微信二维码生成API
        const qrData = await wechatApi.generateQR();
        this.wechatQRCode = qrData.qrCode;
        return qrData;
      } catch (error) {
        console.error('生成微信二维码失败:', error);
        throw error;
      } finally {
        this.loginLoading = false;
      }
    },
    
    /**
     * 检查微信扫码状态
     * @param {string} qrId - 二维码ID
     * @returns {Promise<boolean>} 是否登录成功
     */
    async checkWechatScanStatus(qrId) {
      try {
        const statusData = await wechatApi.checkScanStatus(qrId);
        if (statusData.status === 'success') {
          // 保存token
          TokenManager.setToken(statusData.user.token);
          // 设置用户信息
          this.setUser(statusData.user);
          return true;
        }
        return false;
      } catch (error) {
        console.error('检查扫码状态失败:', error);
        return false;
      }
    },
    
    /**
     * 设置用户信息
     * @param {Object} userData - 用户数据
     */
    setUser(userData) {
      console.log('setUser方法被调用，参数:', userData);
      this.user = userData;
      this.isAuthenticated = true;
      
      // 保存到localStorage
      const userDataToSave = JSON.stringify(userData);
      console.log('准备保存到localStorage的用户数据:', userDataToSave);
      localStorage.setItem('user', userDataToSave);
      
      // 验证保存结果
      const savedData = localStorage.getItem('user');
      console.log('localStorage保存验证:', savedData);
      console.log('store状态更新后:', {
        user: this.user,
        isAuthenticated: this.isAuthenticated
      });
    },
    
    /**
     * 退出登录
     */
    async logout() {
      try {
        // 调用登出API
        await authApi.logout();
      } catch (error) {
        console.error('登出API调用失败:', error);
      } finally {
        // 清除本地状态
        this.user = null;
        this.isAuthenticated = false;
        this.userWorks = [];
        TokenManager.removeToken();
      }
    },
    
    /**
     * 获取用户作品
     * @param {Object} params - 查询参数
     * @returns {Promise<Object>} 作品列表数据
     */
    async fetchUserWorks(params = {}) {
      try {
        const worksData = await userApi.getWorks(params);
        this.userWorks = worksData.works || worksData.data || [];
        return worksData;
      } catch (error) {
        console.error('获取用户作品失败:', error);
        this.userWorks = [];
        throw error;
      }
    },
    
    /**
     * 更新用户信息
     * @param {Object} userInfo - 用户信息
     * @returns {Promise<Object>} 更新后的用户信息
     */
    async updateUserInfo(userInfo) {
      try {
        const updatedUser = await userApi.updateProfile(userInfo);
        this.user = { ...this.user, ...updatedUser };
        localStorage.setItem('user', JSON.stringify(this.user));
        return updatedUser;
      } catch (error) {
        console.error('更新用户信息失败:', error);
        throw error;
      }
    },
    
    /**
     * 初始化用户状态
     */
    initializeAuth() {
      const savedUser = localStorage.getItem('user');
      const token = TokenManager.getToken();
      
      if (savedUser && token && TokenManager.isTokenValid()) {
        this.user = JSON.parse(savedUser);
        this.isAuthenticated = true;
      } else {
        // Token无效或不存在，清除本地数据
        TokenManager.removeToken();
        this.user = null;
        this.isAuthenticated = false;
      }
    },

    /**
     * 上传作品
     * @param {Object} workData - 作品数据
     * @param {File} file - 作品文件
     * @returns {Promise<Object>} 上传结果
     */
    async uploadWork(workData, file) {
      try {
        const formData = new FormData();
        formData.append('title', workData.title);
        formData.append('description', workData.description);
        formData.append('category', workData.category);
        formData.append('tags', workData.tags.join(','));
        formData.append('file', file);
        
        const result = await userApi.uploadWork(formData);
        
        // 刷新用户作品列表
        await this.fetchUserWorks();
        
        return result;
      } catch (error) {
        console.error('作品上传失败:', error);
        throw error;
      }
    },

    /**
     * 删除作品
     * @param {number} workId - 作品ID
     * @returns {Promise<Object>} 删除结果
     */
    async deleteWork(workId) {
      try {
        const result = await userApi.deleteWork(workId);
        
        // 从本地列表中移除
        this.userWorks = this.userWorks.filter(work => work.id !== workId);
        
        return result;
      } catch (error) {
        console.error('删除作品失败:', error);
        throw error;
      }
    },

    /**
     * 更新作品信息
     * @param {number} workId - 作品ID
     * @param {Object} workData - 作品数据
     * @returns {Promise<Object>} 更新结果
     */
    async updateWork(workId, workData) {
      try {
        const result = await userApi.updateWork(workId, workData);
        
        // 更新本地列表中的作品
        const index = this.userWorks.findIndex(work => work.id === workId);
        if (index !== -1) {
          this.userWorks[index] = { ...this.userWorks[index], ...result };
        }
        
        return result;
      } catch (error) {
        console.error('更新作品失败:', error);
        throw error;
      }
    },

    /**
     * 上传头像
     * @param {File} file - 头像文件
     * @returns {Promise<string>} 头像URL
     */
    async uploadAvatar(file) {
      try {
        const avatarUrl = await uploadApi.uploadAvatar(file);
        
        // 更新用户信息中的头像
        await this.updateUserInfo({ avatar: avatarUrl });
        
        return avatarUrl;
      } catch (error) {
        console.error('头像上传失败:', error);
        throw error;
      }
    }
  }
});